import { Question } from "../interface";

const questions: Question[] = [
    {
        question: "TypeScript 是 JavaScript 的什么？",
        radios: [
            "超集（Superset）",
            "子集（Subset）",
            "替代品（Replacement）",
            "编译器（Compiler）"
        ],
        desc: "TypeScript 是 JavaScript 的超集，扩展了类型系统等特性"
    },
    {
        question: "以下哪个不是 TypeScript 的基本类型？",
        radios: [
            "void",
            "never",
            "unknown",
            "object"
        ],
        desc: "所有选项都是 TypeScript 的基本类型，此题设计有误，应更换为其他非基本类型选项"
    },
    {
        question: "关于 interface 和 type 的区别，错误的是：",
        radios: [
            "interface 可以被 extends 和 implements",
            "type 可以使用联合类型和交叉类型",
            "interface 支持声明合并",
            "type 可以被类实现"
        ],
        desc: "type 不能被类实现（implements），只有 interface 可以"
    },
    {
        question: "下列代码的类型注解正确的是：",
        radios: [
            "let x: number = 1;",
            "let y: string = 123;",
            "let z: boolean = 'true';",
            "let arr: Array<number> = ['1', '2'];"
        ],
        muti: true,
        desc: "只有第一个选项的类型注解和赋值匹配"
    },
    {
        question: "关于泛型，正确的是：",
        radios: [
            "可以约束类型参数的范围",
            "只能在函数中使用",
            "泛型参数只能使用大写字母",
            "会增加运行时开销"
        ],
        desc: "泛型可以通过 extends 约束类型参数范围，且不会增加运行时开销"
    },
    {
        question: "下列哪些是 TypeScript 的编译选项？",
        radios: [
            "strictNullChecks",
            "noImplicitAny",
            "target",
            "module"
        ],
        muti: true,
        desc: "所有选项都是合法的 tsconfig.json 编译选项"
    },
    {
        question: "关于类型断言，错误的是：",
        radios: [
            "可以使用 as 语法",
            "可以使用尖括号语法",
            "会进行运行时类型检查",
            "可以强制指定 any 类型"
        ],
        desc: "类型断言是编译时概念，不会影响运行时"
    },
    {
        question: "下列代码的输出结果是什么？\ntype T = { id: number } & { name: string };\nconst obj: T = { id: 1, name: 'test' };",
        radios: [
            "编译错误",
            "{ id: 1, name: 'test' }",
            "{ id: 1 }",
            "{ name: 'test' }"
        ],
        desc: "交叉类型（&）会将多个类型合并，此处可以正确赋值"
    },
    {
        question: "关于枚举（enum），正确的是：",
        radios: [
            "数字枚举支持反向映射",
            "字符串枚举不支持反向映射",
            "const enum 会被完全擦除",
            "枚举成员可以是计算值"
        ],
        muti: true,
        desc: "所有选项都是枚举的正确特性"
    },
    {
        question: "下列哪个装饰器可以修饰类的方法？",
        radios: [
            "@Injectable()",
            "@Component()",
            "@HostListener()",
            "@Input()"
        ],
        desc: "不同框架的装饰器用法不同，但一般 @HostListener 用于方法装饰"
    },
    {
        question: "关于类型守卫，错误的是：",
        radios: [
            "typeof 是类型守卫",
            "instanceof 是类型守卫",
            "自定义类型守卫必须返回 boolean",
            "in 操作符不是类型守卫"
        ],
        desc: "in 操作符也是类型守卫，可以缩小类型范围"
    },
    {
        question: "下列哪些是合法的类型别名定义？",
        radios: [
            "type Person = { name: string };",
            "type ID = number | string;",
            "type Callback = () => void;",
            "type Pair<T> = [T, T];"
        ],
        muti: true,
        desc: "所有选项都是合法的类型别名定义方式"
    },
    {
        question: "关于模块系统，正确的是：",
        radios: [
            "可以使用 import/export 语法",
            "支持 CommonJS 模块",
            "支持 ES 模块",
            "模块解析策略可以配置"
        ],
        muti: true,
        desc: "TypeScript 支持多种模块系统和解析策略"
    },
    {
        question: "下列代码的类型应该是什么？\nconst arr = [1, '2', true];",
        radios: [
            "number[]",
            "string[]",
            "(number | string | boolean)[]",
            "any[]"
        ],
        desc: "数组包含多种类型时，会被推断为联合类型数组"
    },
    {
        question: "关于 keyof 操作符，错误的是：",
        radios: [
            "可以获取对象的所有键",
            "返回类型是 string",
            "可以用于映射类型",
            "keyof any 返回 string | number | symbol"
        ],
        desc: "keyof 返回的是类型（可能是字符串字面量联合类型），不是 string"
    },
    {
        question: "下列哪些工具类型是 TypeScript 内置的？",
        radios: [
            "Partial<T>",
            "Required<T>",
            "Readonly<T>",
            "Nullable<T>"
        ],
        muti: true,
        desc: "Nullable<T> 不是内置工具类型，其他都是"
    },
    {
        question: "关于函数重载，正确的是：",
        radios: [
            "需要多个类型声明",
            "实现函数需要兼容所有重载",
            "可以提高运行时性能",
            "只能用于类方法"
        ],
        muti: true,
        desc: "函数重载是编译时特性，不会影响运行时性能"
    },
    {
        question: "下列代码的类型推断结果是什么？\nconst fn = (x: number) => x > 0 ? x : 'negative';",
        radios: [
            "number",
            "string",
            "number | string",
            "any"
        ],
        desc: "条件类型返回不同结果时，会被推断为联合类型"
    },
    {
        question: "关于声明文件（.d.ts），错误的是：",
        radios: [
            "可以声明类型",
            "可以包含实现代码",
            "用于描述已有 JavaScript 库",
            "编译器会自动读取"
        ],
        desc: "声明文件只包含类型声明，不能包含实现代码"
    },
    {
        question: "下列哪些是合法的类型操作符？",
        radios: [
            "typeof",
            "keyof",
            "instanceof",
            "in"
        ],
        muti: true,
        desc: "所有选项都是合法的类型操作符（instanceof 是类型守卫）"
    },
    {
        question: "关于条件类型，正确的是：",
        radios: [
            "extends 是条件类型关键字",
            "可以嵌套使用",
            "支持 infer 推断",
            "会保留联合类型的分布式特性"
        ],
        muti: true,
        desc: "所有选项都是条件类型的正确特性"
    }
];

export default questions;